#include "lcd.h"
#include "CH58x_common.h"
#include "lcd_init.h"
#include "lcdfont.h"
#include "SGUI_Typedef.h"
#include "ziku_16x16_3500.h"
#if USER_LCD_EN
#if 0
// #include "delay.h"
// #include "spi.h"
// #include "dma.h"
extern volatile uint8_t g_SpiDmaTransFlag;//1：开始/正在传输；0：结束传输；
/******************************************************************************
      函数说明：在指定区域填充颜色
      入口数据：xsta,ysta   起始坐标
                xend,yend   终止坐标
                color       要填充的颜色
      返回值：  无
******************************************************************************/
void LCDP_Fill (uint16_t xsta, uint16_t ysta, uint16_t xend, uint16_t yend, uint16_t color) {
    uint8_t color1[2];
    uint16_t num,packetnum,renum;
    color1[0] = color>>8;
	color1[1] = color;
    num = (xend - xsta) * (yend - ysta)*2;
	packetnum = num/4095;
	renum = num%4095;
	PRINT("num:%d;packetnum:%d;renum:%d\n",num,packetnum,renum);
    LCDP_Address_Set (xsta, ysta, xend - 1, yend - 1);  // 设置显示范围
	
    LCDP_CS_Clr();
    R8_SPI0_CTRL_MOD &= ~RB_SPI_FIFO_DIR;
    R32_SPI0_DMA_BEG = (uint32_t)color1;
    R32_SPI0_DMA_END = (uint32_t)(color1 + 2);
    if (packetnum) {
        R16_SPI0_TOTAL_CNT = 4095;
        // packetnum--;
        // g_SpiDmaTransFlag = 1;
        // R8_SPI0_CTRL_CFG |= RB_SPI_DMA_ENABLE;

    } else {
        R16_SPI0_TOTAL_CNT = renum;
        // g_SpiDmaTransFlag = 1;
        // R8_SPI0_CTRL_CFG |= RB_SPI_DMA_ENABLE;
    }
    R8_SPI0_INT_FLAG = RB_SPI_IF_CNT_END | RB_SPI_IF_DMA_END;
	R8_SPI0_INTER_EN &= ~RB_SPI_IE_DMA_END;
	
    R8_SPI0_CTRL_CFG |= RB_SPI_DMA_ENABLE|RB_SPI_DMA_LOOP;

    while (1) {

        if (SPI0_GetITFlag (RB_SPI_IF_CNT_END)) {
            if (packetnum) {
                R16_SPI0_TOTAL_CNT = 4095;
                packetnum--;
                // g_SpiDmaTransFlag = 1;
                // R8_SPI0_CTRL_CFG |= RB_SPI_DMA_ENABLE;

            } else {
                R16_SPI0_TOTAL_CNT = renum;
                // g_SpiDmaTransFlag = 1;
                // R8_SPI0_CTRL_CFG |= RB_SPI_DMA_ENABLE;
                break;
            }
			SPI0_ClearITFlag (RB_SPI_IF_CNT_END);
        }
    }
    while (!SPI0_GetITFlag(RB_SPI_IF_CNT_END));
	SPI0_ClearITFlag (RB_SPI_IF_CNT_END);
	R8_SPI0_CTRL_CFG &= ~(RB_SPI_DMA_LOOP|RB_SPI_DMA_ENABLE);
	LCDP_CS_Set();
    // R8_SPI0_CTRL_MOD &= ~RB_SPI_FIFO_DIR;
    // for (uint32_t i = 0; i < num; i++) {
    //     R8_SPI0_BUFFER = color >> 8;
    //     while (!(R8_SPI0_INT_FLAG & RB_SPI_FREE))
    //         ;
    //     R8_SPI0_BUFFER = color;
    //     while (!(R8_SPI0_INT_FLAG & RB_SPI_FREE))
    //         ;
    // }

    // SPI1->CR1|=1<<11;//设置SPI16位传输模式
    // SPI_Cmd(SPI1, ENABLE);//使能SPI
    // MYDMA_Config1(DMA1_Channel3,(uint32_t)&SPI1->DR,(uint32_t)color1,num);
    // SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Tx,ENABLE);
    // MYDMA_Enable(DMA1_Channel3);
    // while(1)
    // {
    // 	if(DMA_GetFlagStatus(DMA1_FLAG_TC3)!=RESET)//等待通道4传输完成
    // 	{
    // 		DMA_ClearFlag(DMA1_FLAG_TC3);//清除通道3传输完成标志
    // 		break;
    // 	}
    // }
    
    // SPI1->CR1=~SPI1->CR1;
    // SPI1->CR1|=1<<11;
    // SPI1->CR1=~SPI1->CR1;//设置SPI8位传输模式
    // SPI_Cmd(SPI1, ENABLE);//使能SPI
}

/******************************************************************************
      函数说明：在指定位置画点
      入口数据：x,y 画点坐标
                color 点的颜色
      返回值：  无
******************************************************************************/
void LCDP_DrawPoint (uint16_t x, uint16_t y, uint16_t color) {
    LCDP_Address_Set (x, y, x, y);  // 设置光标位置
    LCDP_WR_DATA (color);
}

/******************************************************************************
      函数说明：画线
      入口数据：x1,y1   起始坐标
                x2,y2   终止坐标
                color   线的颜色
      返回值：  无
******************************************************************************/
void LCDP_DrawLine (uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
    uint16_t t;
    int xerr = 0, yerr = 0, delta_x, delta_y, distance;
    int incx, incy, uRow, uCol;
    delta_x = x2 - x1;  // 计算坐标增量
    delta_y = y2 - y1;
    uRow = x1;          // 画线起点坐标
    uCol = y1;
    if (delta_x > 0)
        incx = 1;  // 设置单步方向
    else if (delta_x == 0)
        incx = 0;  // 垂直线
    else {
        incx = -1;
        delta_x = -delta_x;
    }
    if (delta_y > 0)
        incy = 1;
    else if (delta_y == 0)
        incy = 0;  // 水平线
    else {
        incy = -1;
        delta_y = -delta_y;
    }
    if (delta_x > delta_y)
        distance = delta_x;  // 选取基本增量坐标轴
    else
        distance = delta_y;
    for (t = 0; t < distance + 1; t++) {
        LCDP_DrawPoint (uRow, uCol, color);  // 画点
        xerr += delta_x;
        yerr += delta_y;
        if (xerr > distance) {
            xerr -= distance;
            uRow += incx;
        }
        if (yerr > distance) {
            yerr -= distance;
            uCol += incy;
        }
    }
}

/******************************************************************************
      函数说明：画矩形
      入口数据：x1,y1   起始坐标
                x2,y2   终止坐标
                color   矩形的颜色
      返回值：  无
******************************************************************************/
void LCDP_DrawRectangle (uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
    LCDP_DrawLine (x1, y1, x2, y1, color);
    LCDP_DrawLine (x1, y1, x1, y2, color);
    LCDP_DrawLine (x1, y2, x2, y2, color);
    LCDP_DrawLine (x2, y1, x2, y2, color);
}

/******************************************************************************
      函数说明：画圆
      入口数据：x0,y0   圆心坐标
                r       半径
                color   圆的颜色
      返回值：  无
******************************************************************************/
void Draw_Circle (uint16_t x0, uint16_t y0, uint8_t r, uint16_t color) {
    int a, b;
    a = 0;
    b = r;
    while (a <= b) {
        LCDP_DrawPoint (x0 - b, y0 - a, color);  // 3
        LCDP_DrawPoint (x0 + b, y0 - a, color);  // 0
        LCDP_DrawPoint (x0 - a, y0 + b, color);  // 1
        LCDP_DrawPoint (x0 - a, y0 - b, color);  // 2
        LCDP_DrawPoint (x0 + b, y0 + a, color);  // 4
        LCDP_DrawPoint (x0 + a, y0 - b, color);  // 5
        LCDP_DrawPoint (x0 + a, y0 + b, color);  // 6
        LCDP_DrawPoint (x0 - b, y0 + a, color);  // 7
        a++;
        if ((a * a + b * b) > (r * r))           // 判断要画的点是否过远
        {
            b--;
        }
    }
}

/******************************************************************************
      函数说明：显示汉字串
      入口数据：x,y显示坐标
                *s 要显示的汉字串
                fc 字的颜色
                bc 字的背景色
                sizey 字号 可选 16 24 32
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowChinese (uint16_t x, uint16_t y, uint8_t *s, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    while (*s != 0) {
        if (sizey == 12)
            LCDP_ShowChinese12x12 (x, y, s, fc, bc, sizey, mode);
        else if (sizey == 16)
            LCDP_ShowChinese16x16 (x, y, s, fc, bc, sizey, mode);
        else if (sizey == 24)
            LCDP_ShowChinese24x24 (x, y, s, fc, bc, sizey, mode);
        else if (sizey == 32)
            LCDP_ShowChinese32x32 (x, y, s, fc, bc, sizey, mode);
        else
            return;
        s += 2;
        x += sizey;
    }
}

/******************************************************************************
      函数说明：显示单个12x12汉字
      入口数据：x,y显示坐标
                *s 要显示的汉字
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowChinese12x12 (uint16_t x, uint16_t y, uint8_t *s, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    uint8_t i, j, m = 0;
    uint16_t k;
    uint16_t HZnum;        // 汉字数目
    uint16_t TypefaceNum;  // 一个字符所占字节大小
    uint16_t x0 = x;
    TypefaceNum = (sizey / 8 + ((sizey % 8) ? 1 : 0)) * sizey;

    HZnum = sizeof (tfont12) / sizeof (typFNT_GB12);  // 统计汉字数目
    for (k = 0; k < HZnum; k++) {
        if ((tfont12[k].Index[0] == *(s)) && (tfont12[k].Index[1] == *(s + 1))) {
            LCDP_Address_Set (x, y, x + sizey - 1, y + sizey - 1);
            for (i = 0; i < TypefaceNum; i++) {
                for (j = 0; j < 8; j++) {
                    if (!mode)  // 非叠加方式
                    {
                        if (tfont12[k].Msk[i] & (0x01 << j))
                            LCDP_WR_DATA (fc);
                        else
                            LCDP_WR_DATA (bc);
                        m++;
                        if (m % sizey == 0) {
                            m = 0;
                            break;
                        }
                    } else  // 叠加方式
                    {
                        if (tfont12[k].Msk[i] & (0x01 << j))
                            LCDP_DrawPoint (x, y, fc);  // 画一个点
                        x++;
                        if ((x - x0) == sizey) {
                            x = x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  // 查找到对应点阵字库立即退出，防止多个汉字重复取模带来影响
    }
}

/******************************************************************************
      函数说明：显示单个16x16汉字
      入口数据：x,y显示坐标
                *s 要显示的汉字
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowChinese16x16 (uint16_t x, uint16_t y, uint8_t *s, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    uint8_t i, j, m = 0;
    uint16_t k;
    uint16_t HZnum;        // 汉字数目
    uint16_t TypefaceNum;  // 一个字符所占字节大小
    uint16_t x0 = x;
    TypefaceNum = (sizey / 8 + ((sizey % 8) ? 1 : 0)) * sizey;
    HZnum = sizeof (tfont16) / sizeof (typFNT_GB16);  // 统计汉字数目
    for (k = 0; k < HZnum; k++) {
        if ((tfont16[k].Index[0] == *(s)) && (tfont16[k].Index[1] == *(s + 1))) {
            LCDP_Address_Set (x, y, x + sizey - 1, y + sizey - 1);
            for (i = 0; i < TypefaceNum; i++) {
                for (j = 0; j < 8; j++) {
                    if (!mode)  // 非叠加方式
                    {
                        if (tfont16[k].Msk[i] & (0x01 << j))
                            LCDP_WR_DATA (fc);
                        else
                            LCDP_WR_DATA (bc);
                        m++;
                        if (m % sizey == 0) {
                            m = 0;
                            break;
                        }
                    } else  // 叠加方式
                    {
                        if (tfont16[k].Msk[i] & (0x01 << j))
                            LCDP_DrawPoint (x, y, fc);  // 画一个点
                        x++;
                        if ((x - x0) == sizey) {
                            x = x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  // 查找到对应点阵字库立即退出，防止多个汉字重复取模带来影响
    }
}

/******************************************************************************
      函数说明：显示单个24x24汉字
      入口数据：x,y显示坐标
                *s 要显示的汉字
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowChinese24x24 (uint16_t x, uint16_t y, uint8_t *s, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    uint8_t i, j, m = 0;
    uint16_t k;
    uint16_t HZnum;        // 汉字数目
    uint16_t TypefaceNum;  // 一个字符所占字节大小
    uint16_t x0 = x;
    TypefaceNum = (sizey / 8 + ((sizey % 8) ? 1 : 0)) * sizey;
    HZnum = sizeof (tfont24) / sizeof (typFNT_GB24);  // 统计汉字数目
    for (k = 0; k < HZnum; k++) {
        if ((tfont24[k].Index[0] == *(s)) && (tfont24[k].Index[1] == *(s + 1))) {
            LCDP_Address_Set (x, y, x + sizey - 1, y + sizey - 1);
            for (i = 0; i < TypefaceNum; i++) {
                for (j = 0; j < 8; j++) {
                    if (!mode)  // 非叠加方式
                    {
                        if (tfont24[k].Msk[i] & (0x01 << j))
                            LCDP_WR_DATA (fc);
                        else
                            LCDP_WR_DATA (bc);
                        m++;
                        if (m % sizey == 0) {
                            m = 0;
                            break;
                        }
                    } else  // 叠加方式
                    {
                        if (tfont24[k].Msk[i] & (0x01 << j))
                            LCDP_DrawPoint (x, y, fc);  // 画一个点
                        x++;
                        if ((x - x0) == sizey) {
                            x = x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  // 查找到对应点阵字库立即退出，防止多个汉字重复取模带来影响
    }
}

/******************************************************************************
      函数说明：显示单个32x32汉字
      入口数据：x,y显示坐标
                *s 要显示的汉字
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowChinese32x32 (uint16_t x, uint16_t y, uint8_t *s, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    uint8_t i, j, m = 0;
    uint16_t k;
    uint16_t HZnum;        // 汉字数目
    uint16_t TypefaceNum;  // 一个字符所占字节大小
    uint16_t x0 = x;
    TypefaceNum = (sizey / 8 + ((sizey % 8) ? 1 : 0)) * sizey;
    HZnum = sizeof (tfont32) / sizeof (typFNT_GB32);  // 统计汉字数目
    for (k = 0; k < HZnum; k++) {
        if ((tfont32[k].Index[0] == *(s)) && (tfont32[k].Index[1] == *(s + 1))) {
            LCDP_Address_Set (x, y, x + sizey - 1, y + sizey - 1);
            for (i = 0; i < TypefaceNum; i++) {
                for (j = 0; j < 8; j++) {
                    if (!mode)  // 非叠加方式
                    {
                        if (tfont32[k].Msk[i] & (0x01 << j))
                            LCDP_WR_DATA (fc);
                        else
                            LCDP_WR_DATA (bc);
                        m++;
                        if (m % sizey == 0) {
                            m = 0;
                            break;
                        }
                    } else  // 叠加方式
                    {
                        if (tfont32[k].Msk[i] & (0x01 << j))
                            LCDP_DrawPoint (x, y, fc);  // 画一个点
                        x++;
                        if ((x - x0) == sizey) {
                            x = x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  // 查找到对应点阵字库立即退出，防止多个汉字重复取模带来影响
    }
}

/******************************************************************************
      函数说明：显示单个字符
      入口数据：x,y显示坐标
                num 要显示的字符
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowChar (uint16_t x, uint16_t y, uint8_t num, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    uint8_t temp, sizex, t, m = 0;
    uint16_t i, TypefaceNum;  // 一个字符所占字节大小
    uint16_t x0 = x;
    sizex = sizey / 2;
    TypefaceNum = (sizex / 8 + ((sizex % 8) ? 1 : 0)) * sizey;
    num = num - ' ';                                        // 得到偏移后的值
    LCDP_Address_Set (x, y, x + sizex - 1, y + sizey - 1);  // 设置光标位置
    for (i = 0; i < TypefaceNum; i++) {
        if (sizey == 12)
            temp = ascii_1206[num][i];  // 调用6x12字体
        else if (sizey == 16)
            temp = ascii_1608[num][i];  // 调用8x16字体
        else if (sizey == 24)
            temp = ascii_2412[num][i];  // 调用12x24字体
        else if (sizey == 32)
            temp = ascii_3216[num][i];  // 调用16x32字体
        else
            return;
        for (t = 0; t < 8; t++) {
            if (!mode)  // 非叠加模式
            {
                if (temp & (0x01 << t))
                    LCDP_WR_DATA (fc);
                else
                    LCDP_WR_DATA (bc);
                m++;
                if (m % sizex == 0) {
                    m = 0;
                    break;
                }
            } else  // 叠加模式
            {
                if (temp & (0x01 << t))
                    LCDP_DrawPoint (x, y, fc);  // 画一个点
                x++;
                if ((x - x0) == sizex) {
                    x = x0;
                    y++;
                    break;
                }
            }
        }
    }
}

/******************************************************************************
      函数说明：显示字符串
      入口数据：x,y显示坐标
                *p 要显示的字符串
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCDP_ShowString (uint16_t x, uint16_t y, const uint8_t *p, uint16_t fc, uint16_t bc, uint8_t sizey, uint8_t mode) {
    while (*p != '\0') {
        LCDP_ShowChar (x, y, *p, fc, bc, sizey, mode);
        x += sizey / 2;
        p++;
    }
}

/******************************************************************************
      函数说明：显示数字
      入口数据：m底数，n指数
      返回值：  无
******************************************************************************/
uint32_t mypow (uint8_t m, uint8_t n) {
    uint32_t result = 1;
    while (n--) result *= m;
    return result;
}

/******************************************************************************
      函数说明：显示整数变量
      入口数据：x,y显示坐标
                num 要显示整数变量
                len 要显示的位数
                fc 字的颜色
                bc 字的背景色
                sizey 字号
      返回值：  无
******************************************************************************/
void LCDP_ShowIntNum (uint16_t x, uint16_t y, uint16_t num, uint8_t len, uint16_t fc, uint16_t bc, uint8_t sizey) {
    uint8_t t, temp;
    uint8_t enshow = 0;
    uint8_t sizex = sizey / 2;
    for (t = 0; t < len; t++) {
        temp = (num / mypow (10, len - t - 1)) % 10;
        if (enshow == 0 && t < (len - 1)) {
            if (temp == 0) {
                LCDP_ShowChar (x + t * sizex, y, ' ', fc, bc, sizey, 0);
                continue;
            } else
                enshow = 1;
        }
        LCDP_ShowChar (x + t * sizex, y, temp + 48, fc, bc, sizey, 0);
    }
}

/******************************************************************************
      函数说明：显示两位小数变量
      入口数据：x,y显示坐标
                num 要显示小数变量
                len 要显示的位数
                fc 字的颜色
                bc 字的背景色
                sizey 字号
      返回值：  无
******************************************************************************/
void LCDP_ShowFloatNum1 (uint16_t x, uint16_t y, float num, uint8_t len, uint16_t fc, uint16_t bc, uint8_t sizey) {
    uint8_t t, temp, sizex;
    uint16_t num1;
    sizex = sizey / 2;
    num1 = num * 100;
    for (t = 0; t < len; t++) {
        temp = (num1 / mypow (10, len - t - 1)) % 10;
        if (t == (len - 2)) {
            LCDP_ShowChar (x + (len - 2) * sizex, y, '.', fc, bc, sizey, 0);
            t++;
            len += 1;
        }
        LCDP_ShowChar (x + t * sizex, y, temp + 48, fc, bc, sizey, 0);
    }
}

/******************************************************************************
      函数说明：显示图片
      入口数据：x,y起点坐标
                length 图片长度
                width  图片宽度
                pic[]  图片数组
      返回值：  无
******************************************************************************/
void LCDP_ShowPicture (uint16_t x, uint16_t y, uint16_t length, uint16_t width, const uint8_t pic[]) {
    uint16_t num;
    num = length * width * 2;
    LCDP_Address_Set (x, y, x + length - 1, y + width - 1);
    LCDP_CS_Clr();

    R8_SPI0_CTRL_MOD &= ~RB_SPI_FIFO_DIR;
    for (uint32_t i = 0; i < num; i++) {
        R8_SPI0_BUFFER = pic[i] >> 8;
        while (!(R8_SPI0_INT_FLAG & RB_SPI_FREE))
            ;
        R8_SPI0_BUFFER = pic[i];
        while (!(R8_SPI0_INT_FLAG & RB_SPI_FREE))
            ;
    }

    LCDP_CS_Set();
}

void LCDP_Test(void)
{
    static uint8_t i;
    uint16_t backcolor[21] = {WHITE, BLACK, BLUE, BRED, GRED, GBLUE, RED, MAGENTA, 
                            GREEN, CYAN, YELLOW, BROWN, BRRED, GRAY, DARKBLUE, 
                            LIGHTBLUE, GRAYBLUE, LIGHTGREEN, LGRAY, LGRAYBLUE, LBBLUE};

    LCDP_Fill(0, 0, LCDP_W, LCDP_H, backcolor[i]);
    i = (i + 1) % 21;
}
#else

/******************************************************************************
      گ˽˵ķú՚ָ֨ȸԲͮԤҕɫ
      ɫࠚ˽ߝúxsta,ysta   ǰʼظҪ
                xend,yend   וֹظҪ
                                color       ҪͮԤքҕɫ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_Fill(uint16_t xsta,uint16_t ysta,uint16_t xend,uint16_t yend,uint16_t color)
{
    uint16_t i,j;
    LCDP_Address_Set(xsta,ysta,xend-1,yend-1);//ʨ׃Дʾ׶Χ
    for(i=ysta;i<yend;i++)
    {
        for(j=xsta;j<xend;j++)
        {
            LCD_WR_DATA(color);
        }
    }
}

/******************************************************************************
      گ˽˵ķú՚ָ֨λ׃ۭ֣
      ɫࠚ˽ߝúx,y ۭ֣ظҪ
                color ֣քҕɫ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_DrawPoint(uint16_t x,uint16_t y,uint16_t color)
{
    LCDP_Address_Set(x,y,x,y);//ʨ׃ڢҪλ׃
    LCD_WR_DATA(color);
}


/******************************************************************************
      گ˽˵ķúۭП
      ɫࠚ˽ߝúx1,y1   ǰʼظҪ
                x2,y2   וֹظҪ
                color   Пքҕɫ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_DrawLine(uint16_t x1,uint16_t y1,uint16_t x2,uint16_t y2,uint16_t color)
{
    uint16_t t;
    int xerr=0,yerr=0,delta_x,delta_y,distance;
    int incx,incy,uRow,uCol;
    delta_x=x2-x1; //݆̣ظҪն
    delta_y=y2-y1;
    uRow=x1;//ۭПǰ֣ظҪ
    uCol=y1;
    if(delta_x>0)incx=1; //ʨ׃եҽ׽в
    else if (delta_x==0)incx=0;//ԹֱП
    else {incx=-1;delta_x=-delta_x;}
    if(delta_y>0)incy=1;
    else if (delta_y==0)incy=0;//ˮƽП
    else {incy=-1;delta_y=-delta_y;}
    if(delta_x>delta_y)distance=delta_x; //ѡȡܹѾնظҪס
    else distance=delta_y;
    for(t=0;t<distance+1;t++)
    {
        LCD_DrawPoint(uRow,uCol,color);//ۭ֣
        xerr+=delta_x;
        yerr+=delta_y;
        if(xerr>distance)
        {
            xerr-=distance;
            uRow+=incx;
        }
        if(yerr>distance)
        {
            yerr-=distance;
            uCol+=incy;
        }
    }
}


/******************************************************************************
      گ˽˵ķúۭߘю
      ɫࠚ˽ߝúx1,y1   ǰʼظҪ
                x2,y2   וֹظҪ
                color   ߘюքҕɫ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_DrawRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,uint16_t color)
{
    LCD_DrawLine(x1,y1,x2,y1,color);
    LCD_DrawLine(x1,y1,x1,y2,color);
    LCD_DrawLine(x1,y2,x2,y2,color);
    LCD_DrawLine(x2,y1,x2,y2,color);
}


/******************************************************************************
      گ˽˵ķúۭԲ
      ɫࠚ˽ߝúx0,y0   ԲфظҪ
                r       ѫ޶
                color   Բքҕɫ
      ׵ܘֵú  Ϟ
******************************************************************************/
void Draw_Circle(uint16_t x0,uint16_t y0,uint8_t r,uint16_t color)
{
    int a,b;
    a=0;b=r;
    while(a<=b)
    {
        LCD_DrawPoint(x0-b,y0-a,color);             //3
        LCD_DrawPoint(x0+b,y0-a,color);             //0
        LCD_DrawPoint(x0-a,y0+b,color);             //1
        LCD_DrawPoint(x0-a,y0-b,color);             //2
        LCD_DrawPoint(x0+b,y0+a,color);             //4
        LCD_DrawPoint(x0+a,y0-b,color);             //5
        LCD_DrawPoint(x0+a,y0+b,color);             //6
        LCD_DrawPoint(x0-b,y0+a,color);             //7
        a++;
        if((a*a+b*b)>(r*r))//Ɛ׏Ҫۭք֣ˇرڽԶ
        {
            b--;
        }
    }
}

/******************************************************************************
      گ˽˵ķúДʾںؖԮ
      ɫࠚ˽ߝúx,yДʾظҪ
                *s ҪДʾքںؖԮ
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ ࠉѡ 16 24 32
                mode:  0؇־ݓģʽ  1־ݓģʽ
      ׵ܘֵú  Ϟ
******************************************************************************/
//void LCD_ShowChinese(uint16_t x,uint16_t y,uint8_t *s,uint16_t fc,uint16_t bc,uint8_t sizey,uint8_t mode)
//{
//    while(*s!=0)
//    {
//        if(sizey==12) LCD_ShowChinese12x12(x,y,s,fc,bc,sizey,mode);
//        else if(sizey==16) LCD_ShowChinese16x16(x,y,s,fc,bc,sizey,mode);
//        else if(sizey==24) LCD_ShowChinese24x24(x,y,s,fc,bc,sizey,mode);
//        else if(sizey==32) LCD_ShowChinese32x32(x,y,s,fc,bc,sizey,mode);
//        else return;
//        s+=2;
//        x+=sizey;
//    }
//}

/******************************************************************************
      گ˽˵ķúДʾեٶ12x12ںؖ
      ɫࠚ˽ߝúx,yДʾظҪ
                *s ҪДʾքںؖ
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ
                mode:  0؇־ݓģʽ  1־ݓģʽ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowChinese12x12(uint16_t x,uint16_t y,uint8_t *s,uint16_t fc,uint16_t bc,uint8_t sizey,uint8_t mode)
{
    uint8_t i,j,m=0;
    uint16_t k;
    uint16_t HZnum;//ںؖ˽Ŀ
    uint16_t TypefaceNum;//һٶؖػ̹ռؖޚճС
    uint16_t x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;

    HZnum=sizeof(tfont12)/sizeof(typFNT_GB12);  //ͳ݆ںؖ˽Ŀ
    for(k=0;k<HZnum;k++)
    {
        if((tfont12[k].Index[0]==*(s))&&(tfont12[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)//؇־ݓ׽ʽ
                    {
                        if(tfont12[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else//־ݓ׽ʽ
                    {
                        if(tfont12[k].Msk[i]&(0x01<<j)) LCD_DrawPoint(x,y,fc);//ۭһٶ֣
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  //ө֒սהӦֳ֣ؖࠢbܴ΋Զì؀ֹנٶںؖטشȡģո4ӰЬ
    }
}

/******************************************************************************
      گ˽˵ķúДʾեٶ16x16ںؖ
      ɫࠚ˽ߝúx,yДʾظҪ
                *s ҪДʾքںؖ
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ
                mode:  0؇־ݓģʽ  1־ݓģʽ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowChinese16x16(uint16_t x,uint16_t y,uint8_t *s,uint16_t fc,uint16_t bc,uint8_t sizey,uint8_t mode)
{
    uint8_t i,j,m=0;
    uint16_t k;
    uint16_t HZnum;//ںؖ˽Ŀ
    uint16_t TypefaceNum;//һٶؖػ̹ռؖޚճС
    uint16_t x0=x;
  TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;
    HZnum=sizeof(tfont16)/sizeof(typFNT_GB16);  //ͳ݆ںؖ˽Ŀ
    for(k=0;k<HZnum;k++)
    {
        if ((tfont16[k].Index[0]==*(s))&&(tfont16[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)//؇־ݓ׽ʽ
                    {
                        if(tfont16[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else//־ݓ׽ʽ
                    {
                        if(tfont16[k].Msk[i]&(0x01<<j)) LCD_DrawPoint(x,y,fc);//ۭһٶ֣
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  //ө֒սהӦֳ֣ؖࠢbܴ΋Զì؀ֹנٶںؖטشȡģո4ӰЬ
    }
}

void LCD_ShowString_16X32(uint8_t x,uint8_t y,uint16_t fc,uint16_t bc,char *word_str){
    uint16_t GBK_indax = -1;
    uint8_t word_high;
    uint8_t word_low;

    if (word_str == NULL) {
        return;
    }

    //dk_log_hex("word_str", word_str, strlen(word_str));

    for(int n=0; word_str[n]!='\0'; n++)  //ҩzؖػԮìא/ؖػìƐ׏۳ؖҰˤԶ
    {
        //遇到字符
        if(word_str[n]>31&&word_str[n]<127){
            if(x+8>=LCDP_W){ //自动换行
                x=0;y+=16;
            }
           // LCD_ShowChar(x,y,fc,bc,word_str[n]);
            LCD_ShowChar_16x32(x,y,fc,bc,word_str[n]);
            x+=8;
            continue; //能少写一个else{}
        }
    }
}

void LCD_ShowChinese(uint8_t x,uint8_t y,uint16_t fc,uint16_t bc,char *word_str){
    uint16_t GBK_indax = -1;
    uint8_t word_high;
    uint8_t word_low;

    if (word_str == NULL) {
        return;
    }

    dk_log_hex("word_str", word_str, strlen(word_str));

    for(int n=0; word_str[n]!='\0'; n++)  //ҩzؖػԮìא/ؖػìƐ׏۳ؖҰˤԶ
    {
        //遇到字符
        if(word_str[n]>31&&word_str[n]<127){
            if(x+8>=LCDP_W){ //自动换行
                x=0;y+=16;
            }
           // LCD_ShowChar(x,y,fc,bc,word_str[n]);
            LCD_ShowChar(x,y,fc,bc,word_str[n]);
            x+=8;
            continue; //能少写一个else{}
        }
        word_high = word_str[n];
        word_low = word_str[n+1];
      //  PRINT("word_str[n]:%x,word_str[n+1]%x\r\n", word_high, word_low);
        /*汉字编码查表*/
        for (GBK_indax=0; font_16x16_GBK[GBK_indax]!='\0'; GBK_indax++) {
            if ( font_16x16_GBK[GBK_indax] == (((uint16_t)word_high << 8) | (uint16_t)word_low) ) {
              //  PRINT("GBK_indax:%d\r\n", GBK_indax);
                break;

            }
        }

        if(x+16>=160){
            x=0;y+=16;
        }
        for(int i = 0; i < 16; i++){
            for (int j = 0; j < 8; j++){            //سѫҟ
                if (font_16x16[GBK_indax][2*i]&(0x80>>j)) //ӲΪאτ2ٶؖޚìسӠǡۃȫΪż˽ìԒӠȫΪǦ˽
                    LCD_DrawPoint(x+j,y+i,fc);        //˽ةאìÿlѸք}ٶԪ̘ì֣һѐc
                else                                //ڊ׸Ǧ˽Ԫ̘؜ˇغհسѫѐìż˽غհԒѫѐ
                    LCD_DrawPoint(x+j,y+i,bc);
            }
            for (int j = 0; j < 8; j++){              //ԒѫҟìԒӠΪǦ˽
                if (font_16x16[GBK_indax][2*i+1]&(0x80>>j)) //k*32փս՚ؖģ˽ةאքԵʼЂҪ
                    LCD_DrawPoint(x+j+8,y+i,fc);
                else
                    LCD_DrawPoint(x+j+8,y+i,bc);
            }
        }
        x+=16;  //ټтλ׃
        n+=1;   //ϒ֢oһٶںؖռ3ٶλ׃ì̹Ӕݓ2
    }
}


/******************************************************************************
      گ˽˵ķúДʾեٶ24x24ںؖ
      ɫࠚ˽ߝúx,yДʾظҪ
                *s ҪДʾքںؖ
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ
                mode:  0؇־ݓģʽ  1־ݓģʽ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowChinese24x24(uint16_t x,uint16_t y,uint8_t *s,uint16_t fc,uint16_t bc,uint8_t sizey,uint8_t mode)
{
    uint8_t i,j,m=0;
    uint16_t k;
    uint16_t HZnum;//ںؖ˽Ŀ
    uint16_t TypefaceNum;//һٶؖػ̹ռؖޚճС
    uint16_t x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;
    HZnum=sizeof(tfont24)/sizeof(typFNT_GB24);  //ͳ݆ںؖ˽Ŀ
    for(k=0;k<HZnum;k++)
    {
        if ((tfont24[k].Index[0]==*(s))&&(tfont24[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)//؇־ݓ׽ʽ
                    {
                        if(tfont24[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else//־ݓ׽ʽ
                    {
                        if(tfont24[k].Msk[i]&(0x01<<j)) LCD_DrawPoint(x,y,fc);//ۭһٶ֣
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  //ө֒սהӦֳ֣ؖࠢbܴ΋Զì؀ֹנٶںؖטشȡģո4ӰЬ
    }
}

/******************************************************************************
      گ˽˵ķúДʾեٶ32x32ںؖ
      ɫࠚ˽ߝúx,yДʾظҪ
                *s ҪДʾքںؖ
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ
                mode:  0؇־ݓģʽ  1־ݓģʽ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowChinese32x32(uint16_t x,uint16_t y,uint8_t *s,uint16_t fc,uint16_t bc,uint8_t sizey,uint8_t mode)
{
    uint8_t i,j,m=0;
    uint16_t k;
    uint16_t HZnum;//ںؖ˽Ŀ
    uint16_t TypefaceNum;//һٶؖػ̹ռؖޚճС
    uint16_t x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;
    HZnum=sizeof(tfont32)/sizeof(typFNT_GB32);  //ͳ݆ںؖ˽Ŀ
    for(k=0;k<HZnum;k++)
    {
        if ((tfont32[k].Index[0]==*(s))&&(tfont32[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)//؇־ݓ׽ʽ
                    {
                        if(tfont32[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else//־ݓ׽ʽ
                    {
                        if(tfont32[k].Msk[i]&(0x01<<j)) LCD_DrawPoint(x,y,fc);//ۭһٶ֣
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;  //ө֒սהӦֳ֣ؖࠢbܴ΋Զì؀ֹנٶںؖטشȡģո4ӰЬ
    }
}


/*
功能：仅输出字符
参数：坐标，字体颜色，背景颜色，字符内容
解释：字模数组，一个8位数据元素，用于控制8个像素点的亮灭，仅为01，与图片时的颜色数据无关，不要理解混了
      这里其实很类似于点阵屏，只不过把LEd 替换成 像素点就可以，同样由二进制01控制打开关闭
      字符像素大小：8*16 宽8高， 一个8位数组元素，点亮一行，共16行，也就是16个数组元素记录一个字符
*/
void LCD_ShowChar(uint8_t x,uint8_t y,uint16_t fc,uint16_t bc,char c){

    for (int i = 0; i < 16; i++)         //行16  字模高度
        for (int j = 0; j < 8; j++) {      //列8   字模宽度
            if (ASCII_8x16[c-32][i]&(0x80>>j))
                LCD_DrawPoint(x+j,y+i,fc); //点亮不同位置的点，亮与不亮的点，构成字符外观
            else
                LCD_DrawPoint(x+j,y+i,bc);
        }
}

const uint8_t TimeAscii_16x32[][32] ={
        {0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x3C,0x64,0x66,0x42,0x42,0x42,0x42,0x42,0x42,
        0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x66,0x64,0x3C,0x3C,0x18,0x00,0x00,0x00,0x00},/*"0",0*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x18,0x18,0x38,0x38,0x78,0x58,0x18,0x18,0x18,
        0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00},/*"1",1*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x3C,0x66,0x46,0x42,0x42,0x02,0x06,0x06,0x04,
        0x04,0x0C,0x08,0x18,0x10,0x10,0x30,0x20,0x60,0x7E,0x7E,0x00,0x00,0x00,0x00,0x00},/*"2",2*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x3C,0x66,0x46,0x42,0x42,0x02,0x06,0x04,0x1C,
        0x1C,0x0C,0x06,0x02,0x02,0x02,0x42,0x46,0x66,0x7C,0x3C,0x10,0x00,0x00,0x00,0x00},/*"3",3*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x0C,0x0C,0x0C,0x1C,0x14,0x14,0x34,0x24,
        0x24,0x64,0x44,0xC4,0xFF,0xFF,0xFF,0x04,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00},/*"4",4*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x3E,0x3E,0x60,0x60,0x40,0x40,0x40,0x78,0x7C,0x6C,
         0x46,0x02,0x02,0x02,0x02,0x02,0xC2,0xC6,0x46,0x7C,0x3C,0x10,0x00,0x00,0x00,0x00},/*"5",5*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x08,0x18,0x18,0x10,0x10,0x30,0x20,0x3C,0x7E,
        0x66,0x42,0x43,0x43,0x43,0x43,0x42,0x42,0x66,0x7E,0x3C,0x18,0x00,0x00,0x00,0x00},/*"6",6*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x7E,0x7E,0x02,0x02,0x06,0x04,0x04,0x04,0x0C,0x08,
        0x08,0x08,0x08,0x18,0x10,0x10,0x10,0x10,0x30,0x30,0x30,0x00,0x00,0x00,0x00,0x00},/*"7",7*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x3C,0x66,0x46,0x42,0x42,0x46,0x46,0x64,0x3C,
        0x3C,0x6E,0x46,0x42,0xC2,0xC2,0xC2,0x42,0x46,0x7C,0x3C,0x18,0x00,0x00,0x00,0x00},/*"8",8*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x7C,0x66,0x46,0xC2,0xC2,0xC2,0xC2,0xC6,0xC6,
        0x44,0x7C,0x3C,0x0C,0x08,0x08,0x18,0x18,0x10,0x10,0x30,0x20,0x00,0x00,0x00,0x00},/*"9",9*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x18,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00},/*":",10*/

        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",11*/


};

/*
功能：仅输出字符
参数：坐标，字体颜色，背景颜色，字符内容
解释：字模数组，一个8位数据元素，用于控制8个像素点的亮灭，仅为01，与图片时的颜色数据无关，不要理解混了
      这里其实很类似于点阵屏，只不过把LEd 替换成 像素点就可以，同样由二进制01控制打开关闭
      字符像素大小：16*32 宽16高32， 一个8位数组元素，点亮一行，共32行，也就是16个数组元素记录一个字符
*/
void LCD_ShowChar_16x32(uint8_t x,uint8_t y,uint16_t fc,uint16_t bc, char num){
    uint8_t index = 0;

    if(num>= '0' && num <= '9'){
        index = num - '0';
    }
    else if(num == ':'){
        index = 10;
    }
    else {
        index = 11;
    }
    PRINT("index:%d\r\n", index);
    for (int i = 0; i < 32; i++)         //行16  字模高度
        for (int j = 0; j < 8; j++) {      //列8   字模宽度
            if (TimeAscii_16x32[index][i]&(0x80>>j))
                LCD_DrawPoint(x+j,y+i,fc); //点亮不同位置的点，亮与不亮的点，构成字符外观
            else
                LCD_DrawPoint(x+j,y+i,bc);
        }
}
/******************************************************************************
      函数说明：显示字符串
      入口数据：x,y显示坐标
                *p 要显示的字符串
                fc 字的颜色
                bc 字的背景色
                sizey 字号
                mode:  0非叠加模式  1叠加模式
      返回值：  无
******************************************************************************/
void LCD_ShowString(uint16_t x,uint16_t y,const uint8_t *p,uint16_t fc,uint16_t bc,uint8_t sizey,uint8_t mode)
{
    while(*p!='\0')
    {
        //LCD_ShowChar(x,y,*p,fc,bc,sizey,mode);
        x+=sizey/2;
        p++;
    }
}


/******************************************************************************
      گ˽˵ķúДʾ˽ؖ
      ɫࠚ˽ߝúm֗˽ìnָ˽
      ׵ܘֵú  Ϟ
******************************************************************************/
uint32_t mypow(uint8_t m,uint8_t n)
{
    uint32_t result=1;
    while(n--)result*=m;
    return result;
}


/******************************************************************************
      گ˽˵ķúДʾֻ˽Ҥ
      ɫࠚ˽ߝúx,yДʾظҪ
                num ҪДʾֻ˽Ҥ
                len ҪДʾքλ˽
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowIntNum(uint16_t x,uint16_t y,uint16_t num,uint8_t len,uint16_t fc,uint16_t bc,uint8_t sizey)
{
    uint8_t t,temp;
    uint8_t enshow=0;
    uint8_t sizex=sizey/2;
    for(t=0;t<len;t++)
    {
        temp=(num/mypow(10,len-t-1))%10;
        if(enshow==0&&t<(len-1))
        {
            if(temp==0)
            {
                //LCD_ShowChar(x+t*sizex,y,' ',fc,bc,sizey,0);
                continue;
            }else enshow=1;

        }
       // LCD_ShowChar(x+t*sizex,y,temp+48,fc,bc,sizey,0);
    }
}


/******************************************************************************
      گ˽˵ķúДʾ}λС˽Ҥ
      ɫࠚ˽ߝúx,yДʾظҪ
                num ҪДʾС˽Ҥ
                len ҪДʾքλ˽
                fc ؖքҕɫ
                bc ؖքѳްɫ
                sizey ؖۅ
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowFloatNum1(uint16_t x,uint16_t y,float num,uint8_t len,uint16_t fc,uint16_t bc,uint8_t sizey)
{
    uint8_t t,temp,sizex;
    uint16_t num1;
    sizex=sizey/2;
    num1=num*100;
    for(t=0;t<len;t++)
    {
        temp=(num1/mypow(10,len-t-1))%10;
        if(t==(len-2))
        {
            //LCD_ShowChar(x+(len-2)*sizex,y,'.',fc,bc,sizey,0);
            t++;
            len+=1;
        }
       // LCD_ShowChar(x+t*sizex,y,temp+48,fc,bc,sizey,0);
    }
}


/******************************************************************************
      گ˽˵ķúДʾͼƬ
      ɫࠚ˽ߝúx,yǰ֣ظҪ
                length ͼƬӤ׈
                width  ͼƬ࠭׈
                pic[]  ͼƬ˽ة
      ׵ܘֵú  Ϟ
******************************************************************************/
void LCD_ShowPicture(uint16_t x,uint16_t y,uint16_t length,uint16_t width,const uint8_t pic[])
{
    uint16_t i,j;
    uint32_t k=0;
    LCD_Address_Set(x,y,x+length-1,y+width-1);
    for(i=0;i<length;i++)
    {
        for(j=0;j<width;j++)
        {
            LCD_WR_DATA8(pic[k*2]);
            LCD_WR_DATA8(pic[k*2+1]);
            k++;
        }
    }
}

__HIGH_CODE
void SGUI_SDK_SetPixel(SGUI_INT iX, SGUI_INT iY, SGUI_UINT iColor)
{
//    SGUI_INT pos, page, temp;
//
//    if (iX > 127 || iY > 63)
//    {
//        return;
//    }
//
//    page = 7 - iY / 8;
//    pos = iY % 8;
//    temp = 1 << (7 - pos);
//    if (iColor == 1)
//        OLED_GRAM[page][iX] |= temp;
//    else
//        OLED_GRAM[page][iX] &= ~temp;

    LCD_Address_Set(iX,iY,iX,iY);//ʨ׃ڢҪλ׃
    if(iColor == 0){
        LCD_WR_DATA(LIGHTBLUE);
    }
    else{
        LCD_WR_DATA(WHITE);
    }
}

/*******************************************************************************
* Function Name  : SGUI_SDK_GetPixel
* Description    : 获取OLED(x,y)坐标处的灯亮灭状态
* Input          : iX: 横坐标，显示屏由左到右
                   iY: 纵坐标，显示屏由上到下
* Return         : s: 1/0 = 亮/灭
*******************************************************************************/
__HIGH_CODE
SGUI_INT SGUI_SDK_GetPixel(SGUI_INT iX, SGUI_INT iY)
{
//    SGUI_INT pos, page, temp;
//
//    if (iX > 127 || iY > 63)
//        return 0;
//
//    page = 7 - iY / 8;
//    pos = iY % 8;
//    temp = 1 << (7 - pos);
//    if (OLED_GRAM[page][iX] & temp)
//        return 1;
//    else
//        return 0;
    return 1;
}

void SGUI_SDK_ClearDisplay(void){
    LCD_Fill(0,0,LCDP_W,LCDP_H,LIGHTBLUE);
}

__HIGH_CODE
void SGUI_SDK_RefreshDisplay(void)
{
    ;
}
#endif
#endif
